{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "cell_id": "57654ce51cf5479db3e9250a67bc21be",
    "deepnote_app_coordinates": {
     "h": 5,
     "w": 12,
     "x": 0,
     "y": 25
    },
    "deepnote_cell_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数据集大小： 100000\n",
      "用户数：943，电影数：1682\n",
      "[215  47  42  19 139 170 320  47  18 156]\n",
      "[371 109  70 172  70  21 308 158 240  68]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm # 进度条工具\n",
    "\n",
    "data = np.loadtxt('movielens_100k.csv', delimiter=',', dtype=int)\n",
    "print('数据集大小：', len(data))\n",
    "# 用户和电影都是从1开始编号的，我们将其转化为从0开始\n",
    "data[:, :2] = data[:, :2] - 1\n",
    "\n",
    "# 计算用户和电影数量\n",
    "users = set()\n",
    "items = set()\n",
    "for i, j, k in data:\n",
    "    users.add(i)\n",
    "    items.add(j)\n",
    "user_num = len(users)\n",
    "item_num = len(items)\n",
    "print(f'用户数：{user_num}，电影数：{item_num}')\n",
    "\n",
    "# 设置随机种子，划分训练集与测试集\n",
    "np.random.seed(0)\n",
    "\n",
    "ratio = 0.8\n",
    "split = int(len(data) * ratio)\n",
    "np.random.shuffle(data)\n",
    "train = data[:split]\n",
    "test = data[split:]\n",
    "\n",
    "# 统计训练集中每个用户和电影出现的数量，作为正则化的权重\n",
    "user_cnt = np.bincount(train[:, 0], minlength=user_num)\n",
    "item_cnt = np.bincount(train[:, 1], minlength=item_num)\n",
    "print(user_cnt[:10])\n",
    "print(item_cnt[:10])\n",
    "\n",
    "# 用户和电影的编号要作为下标，必须保存为整数\n",
    "user_train, user_test = train[:, 0], test[:, 0]\n",
    "item_train, item_test = train[:, 1], test[:, 1]\n",
    "y_train, y_test = train[:, 2], test[:, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "cell_id": "eb7e34b4066c44c584f557951884b425",
    "deepnote_app_coordinates": {
     "h": 5,
     "w": 12,
     "x": 0,
     "y": 37
    },
    "deepnote_cell_type": "code"
   },
   "outputs": [],
   "source": [
    "class MF:\n",
    "    \n",
    "    def __init__(self, N, M, d):\n",
    "        # N是用户数量，M是电影数量，d是特征维度\n",
    "        # 定义模型参数\n",
    "        self.user_params = np.ones((N, d))\n",
    "        self.item_params = np.ones((M, d))\n",
    "        \n",
    "    def pred(self, user_id, item_id):\n",
    "        # 预测用户user_id对电影item_id的打分\n",
    "        # 获得用户偏好和电影特征\n",
    "        user_param = self.user_params[user_id]\n",
    "        item_param = self.item_params[item_id]\n",
    "        # 返回预测的评分\n",
    "        rating_pred = np.sum(user_param * item_param, axis=1)\n",
    "        return rating_pred\n",
    "    \n",
    "    def update(self, user_grad, item_grad, lr):\n",
    "        # 根据参数的梯度更新参数\n",
    "        self.user_params -= lr * user_grad\n",
    "        self.item_params -= lr * item_grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "cell_id": "e4c6edbad5dd4d33924f22998316f8ac",
    "deepnote_app_coordinates": {
     "h": 5,
     "w": 12,
     "x": 0,
     "y": 49
    },
    "deepnote_cell_type": "code"
   },
   "outputs": [],
   "source": [
    "def train(model, learning_rate, lbd, max_training_step, batch_size):\n",
    "    train_losses = []\n",
    "    test_losses = []\n",
    "    batch_num = int(np.ceil(len(user_train) / batch_size))\n",
    "    with tqdm(range(max_training_step * batch_num)) as pbar:\n",
    "        for epoch in range(max_training_step):\n",
    "            # 随机梯度下降\n",
    "            train_rmse = 0\n",
    "            for i in range(batch_num):\n",
    "                # 获取当前批量\n",
    "                st = i * batch_size\n",
    "                ed = min(len(user_train), st + batch_size)\n",
    "                user_batch = user_train[st: ed]\n",
    "                item_batch = item_train[st: ed]\n",
    "                y_batch = y_train[st: ed]\n",
    "                # 计算模型预测\n",
    "                y_pred = model.pred(user_batch, item_batch)\n",
    "                # 计算梯度\n",
    "                P = model.user_params\n",
    "                Q = model.item_params\n",
    "                errs = y_batch - y_pred\n",
    "                P_grad = np.zeros_like(P)\n",
    "                Q_grad = np.zeros_like(Q)\n",
    "                for user, item, err in zip(user_batch, item_batch, errs):\n",
    "                    P_grad[user] = P_grad[user] - err * Q[item] + lbd * P[user]\n",
    "                    Q_grad[item] = Q_grad[item] - err * P[user] + lbd * Q[item]\n",
    "                model.update(P_grad / len(user_batch), Q_grad / len(user_batch), learning_rate)\n",
    "                \n",
    "                train_rmse += np.mean(errs ** 2)\n",
    "                # 更新进度条\n",
    "                pbar.set_postfix({\n",
    "                    'Epoch': epoch,\n",
    "                    'Train RMSE': f'{np.sqrt(train_rmse / (i + 1)):.4f}',\n",
    "                    'Test RMSE': f'{test_losses[-1]:.4f}' if test_losses else None\n",
    "                })\n",
    "                pbar.update(1)\n",
    "\n",
    "            # 计算 RMSE 损失\n",
    "            train_rmse = np.sqrt(train_rmse / len(user_train))\n",
    "            train_losses.append(train_rmse)\n",
    "            y_test_pred = model.pred(user_test, item_test)\n",
    "            test_rmse = np.sqrt(np.mean((y_test - y_test_pred) ** 2))\n",
    "            test_losses.append(test_rmse)\n",
    "    \n",
    "    return train_losses, test_losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "cell_id": "f9c3bdf9f8134ae191f480013f31b916",
    "deepnote_app_coordinates": {
     "h": 5,
     "w": 12,
     "x": 0,
     "y": 61
    },
    "deepnote_cell_type": "code"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████| 37500/37500 [02:34<00:00, 242.78it/s, Epoch=29, Train RMSE=0.9673, Test RMSE=1.0048]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 超参数\n",
    "feature_num = 16 # 特征数\n",
    "learning_rate = 0.1 # 学习率\n",
    "lbd = 1e-4 # 正则化强度\n",
    "max_training_step = 30\n",
    "batch_size = 64 # 批量大小\n",
    "\n",
    "# 建立模型\n",
    "model = MF(user_num, item_num, feature_num)\n",
    "# 训练部分\n",
    "train_losses, test_losses = train(model, learning_rate, lbd, \n",
    "    max_training_step, batch_size)\n",
    "\n",
    "plt.figure()\n",
    "x = np.arange(max_training_step) + 1\n",
    "plt.plot(x, train_losses, color='blue', label='train loss')\n",
    "plt.plot(x, test_losses, color='red', ls='--', label='test loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('RMSE')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "cell_id": "49e35d9ebe1f4722aba0b8a2d3283441",
    "deepnote_app_coordinates": {
     "h": 5,
     "w": 12,
     "x": 0,
     "y": 73
    },
    "deepnote_cell_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.57712395 3.48622005 3.76150216 3.58604004 4.8058418  3.47284112\n",
      " 3.37246031 4.0917956  3.02605747 3.45742155]\n",
      "[2 4 4 4 5 2 3 1 4 4]\n"
     ]
    }
   ],
   "source": [
    "y_test_pred = model.pred(user_test, item_test)\n",
    "print(y_test_pred[:10]) # 把张量转换为numpy数组\n",
    "print(y_test[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "cell_id": "bb235f3ac34d403cb7e561122d8f4714",
    "deepnote_app_coordinates": {
     "h": 5,
     "w": 12,
     "x": 0,
     "y": 103
    },
    "deepnote_cell_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集大小： 800\n",
      "测试集大小： 200\n",
      "特征数： 24\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import metrics # sklearn中的评价指标函数库\n",
    "from tqdm import tqdm\n",
    "\n",
    "# 导入数据集\n",
    "data = np.loadtxt('fm_dataset.csv', delimiter=',')\n",
    "\n",
    "# 划分数据集\n",
    "np.random.seed(0)\n",
    "ratio = 0.8\n",
    "split = int(ratio * len(data))\n",
    "x_train = data[:split, :-1]\n",
    "y_train = data[:split, -1]\n",
    "x_test = data[split:, :-1]\n",
    "y_test = data[split:, -1]\n",
    "# 特征数\n",
    "feature_num = x_train.shape[1]\n",
    "print('训练集大小：', len(x_train))\n",
    "print('测试集大小：', len(x_test))\n",
    "print('特征数：', feature_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "cell_id": "a2fe9d6caf574c71833830292d742d28",
    "deepnote_app_coordinates": {
     "h": 5,
     "w": 12,
     "x": 0,
     "y": 115
    },
    "deepnote_cell_type": "code"
   },
   "outputs": [],
   "source": [
    "class FM:\n",
    "\n",
    "    def __init__(self, feature_num, vector_dim):\n",
    "        # vector_dim代表公式中的k，为向量v的维度\n",
    "        self.theta0 = 0.0 # 常数项\n",
    "        self.theta = np.zeros(feature_num) # 线性参数\n",
    "        self.v = np.random.normal(size=(feature_num, vector_dim)) # 双线性参数\n",
    "        self.eps = 1e-6 # 精度参数\n",
    "        \n",
    "    def _logistic(self, x):\n",
    "        # 工具函数，用于将预测转化为概率\n",
    "        return 1 / (1 + np.exp(-x))\n",
    "\n",
    "    def pred(self, x):\n",
    "        # 线性部分\n",
    "        linear_term = self.theta0 + x @ self.theta\n",
    "        # 双线性部分\n",
    "        square_of_sum = np.square(x @ self.v)\n",
    "        sum_of_square = np.square(x) @ np.square(self.v)\n",
    "        # 最终预测\n",
    "        y_pred = self._logistic(linear_term \\\n",
    "            + 0.5 * np.sum(square_of_sum - sum_of_square, axis=1))\n",
    "        # 为了防止后续梯度过大，对预测值进行裁剪，将其限制在某一范围内\n",
    "        y_pred = np.clip(y_pred, self.eps, 1 - self.eps)\n",
    "        return y_pred\n",
    "    \n",
    "    def update(self, grad0, grad_theta, grad_v, lr):\n",
    "        self.theta0 -= lr * grad0\n",
    "        self.theta -= lr * grad_theta\n",
    "        self.v -= lr * grad_v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "cell_id": "e624d0064abc4464a471f7587a9ccc0d",
    "deepnote_app_coordinates": {
     "h": 5,
     "w": 12,
     "x": 0,
     "y": 127
    },
    "deepnote_cell_type": "code"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████| 200/200 [01:00<00:00,  3.31it/s, 训练轮数=199, 训练损失=11.3006, 训练集准确率=0.816, 测试集准确率=0.785]200 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试集准确率：0.79，\t测试集AUC：0.7201320910484726\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# 超参数设置，包括学习率、训练轮数等\n",
    "vector_dim = 16\n",
    "learning_rate = 0.01\n",
    "lbd = 0.05\n",
    "max_training_step = 200\n",
    "batch_size = 32\n",
    "\n",
    "# 初始化模型\n",
    "np.random.seed(0)\n",
    "model = FM(feature_num, vector_dim)\n",
    "\n",
    "train_acc = []\n",
    "test_acc = []\n",
    "train_auc = []\n",
    "test_auc = []\n",
    "\n",
    "with tqdm(range(max_training_step)) as pbar:\n",
    "    for epoch in pbar:\n",
    "        st = 0\n",
    "        while st < len(x_train):\n",
    "            ed = min(st + batch_size, len(x_train))\n",
    "            X = x_train[st: ed]\n",
    "            Y = y_train[st: ed]\n",
    "            st += batch_size\n",
    "            # 计算模型预测\n",
    "            y_pred = model.pred(X)\n",
    "            # 计算交叉熵损失\n",
    "            cross_entropy = -Y * np.log(y_pred) \\\n",
    "                - (1 - Y) * np.log(1 - y_pred)\n",
    "            loss = np.sum(cross_entropy)\n",
    "            # 计算损失函数对y的梯度，再根据链式法则得到总梯度\n",
    "            grad_y = (y_pred - Y).reshape(-1, 1)\n",
    "            # 计算y对参数的梯度\n",
    "            # 常数项\n",
    "            grad0 = np.sum(grad_y * (1 / len(X) + lbd))\n",
    "            # 线性项\n",
    "            grad_theta = np.sum(grad_y * (X / len(X) \\\n",
    "                + lbd * model.theta), axis=0)\n",
    "            # 双线性项\n",
    "            grad_v = np.zeros((feature_num, vector_dim))\n",
    "            for i, x in enumerate(X):\n",
    "                # 先计算sum(x_i * v_i)\n",
    "                xv = x @ model.v\n",
    "                grad_vi = np.zeros((feature_num, vector_dim))\n",
    "                for s in range(feature_num):\n",
    "                    grad_vi[s] += x[s] * xv - (x[s] ** 2) * model.v[s]\n",
    "                grad_v += grad_y[i] * grad_vi\n",
    "            grad_v = grad_v / len(X) + lbd * model.v\n",
    "            model.update(grad0, grad_theta, grad_v, learning_rate)\n",
    "\n",
    "            pbar.set_postfix({\n",
    "                '训练轮数': epoch,\n",
    "                '训练损失': f'{loss:.4f}',\n",
    "                '训练集准确率': train_acc[-1] if train_acc else None,\n",
    "                '测试集准确率': test_acc[-1] if test_acc else None\n",
    "            })\n",
    "        # 计算模型预测的准确率和AUC\n",
    "        # 预测准确率，阈值设置为0.5\n",
    "        y_train_pred = (model.pred(x_train) >= 0.5)\n",
    "        acc = np.mean(y_train_pred == y_train)\n",
    "        train_acc.append(acc)\n",
    "        auc = metrics.roc_auc_score(y_train, y_train_pred) # sklearn中的AUC函数\n",
    "        train_auc.append(auc)\n",
    "\n",
    "        y_test_pred = (model.pred(x_test) >= 0.5)\n",
    "        acc = np.mean(y_test_pred == y_test)\n",
    "        test_acc.append(acc)\n",
    "        auc = metrics.roc_auc_score(y_test, y_test_pred) \n",
    "        test_auc.append(auc)\n",
    "            \n",
    "print(f'测试集准确率：{test_acc[-1]}，\\t测试集AUC：{test_auc[-1]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "cell_id": "a0f21191b7da4a109e2748dda3d89fa6",
    "deepnote_app_coordinates": {
     "h": 5,
     "w": 12,
     "x": 0,
     "y": 139
    },
    "deepnote_cell_type": "code"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1300x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制训练曲线            \n",
    "plt.figure(figsize=(13, 5))\n",
    "x_plot = np.arange(len(train_acc)) + 1\n",
    "\n",
    "plt.subplot(121)\n",
    "plt.plot(x_plot, train_acc, color='blue', label='train acc')\n",
    "plt.plot(x_plot, test_acc, color='red', ls='--', label='test acc')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(122)\n",
    "plt.plot(x_plot, train_auc, color='blue', label='train AUC')\n",
    "plt.plot(x_plot, test_auc, color='red', ls='--', label='test AUC')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('AUC')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "deepnote": {},
  "deepnote_app_layout": "article",
  "deepnote_execution_queue": [],
  "deepnote_notebook_id": "8930ea4aee414a189695f7cc8680b391",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
